{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 交通信号灯分类器\n",
    "---\n",
    "\n",
    "在这个项目中，你将使用计算机视觉技术的知识为交通信号灯图像建立一个分类器！你会获得一个交通信号灯图像数据集，里面包含三种交通信号灯，即红灯、黄灯或绿灯，其中，三分之一的灯是亮起的。\n",
    "\n",
    "在该 notebook 中，你将对这些图像进行预处理，提取有助于我们区分不同类型图像的特征，并使用这些特征将交通信号灯图像分为三类：红灯、黄灯或绿灯。所有这些任务将会分解成几个部分：\n",
    "\n",
    "1. **加载和可视化数据**。\n",
    "      任何一种分类任务的第一步都是熟悉你的数据；在这里，你需要加载交通信号灯的图像并将其可视化！\n",
    "\n",
    "2. **预处理**。\n",
    "    输入的图像和输出的标签都需要是标准化的。通过这种方式，你可以使用相同的分类器分析所有输入的图像，并且知道在最终对一个*新*图像进行分类时需要输出什么样的图像。\n",
    "\n",
    "3. **特征提取**。\n",
    "    接下来，你需要从每幅图像中提取一些特征，从而帮助区分这些图像，并最终对这些图像进行分类。\n",
    "\n",
    "4. **进行分类，并将错误可视化**。\n",
    "     最后，你需要编写一个利用你提取的特征对*任何一个*交通信号灯图像进行分类的函数。该函数将输入一个图像，然后输出一个标签。你还会获得相关代码，用于确定分类模型的准确度。   \n",
    "\n",
    "5. **评估你的模型**。\n",
    "    要通过此项目，你的分类器的准确度必须 > 90％，并且不能将任何一个红灯归类为绿灯；你很可能需要通过更改现有特征或添加新特征来提高分类器的准确度。我也鼓励你多进行尝试，让准确度尽可能接近100％！\n",
    "\n",
    "以下是数据集中的一些示例图像（从左到右：红灯、绿灯与黄灯）：\n",
    "<img src=\"images/all_lights.png\" width=\"50%\" height=\"50%\">\n",
    "\n",
    "---\n",
    "### *以下是完成该项目所需了解的内容：*\n",
    "\n",
    "我们已经为你提供了一些模板代码，但你需要执行其他代码步骤才能成功完成此项目。任何一个通过此项目所需的代码的标题中都标有**'(IMPLEMENTATION)'**。在完成此项目时，你还需要回答一些关于你的思路的问题，这些问题在标题中都标有**'(QUESTION)'**。请务必回答所有问题，并根据 [项目审阅标准](https://review.udacity.com/#!/rubrics/1213/view) 检查你的代码，确保你完成了必要的几个分类步骤！\n",
    "\n",
    "你提交的项目将根据你提供的代码运行情况以及两个主要分类标准进行评估。\n",
    "提交的完整交通信号灯分类器应满足下面两个标准：\n",
    "1. **准确度超过90％**\n",
    "2. ***不要* 将任何一个红灯分类为绿灯**\n",
    "\n",
    "\n",
    "# 1. 加载交通信号灯数据集，并将其可视化\n",
    "\n",
    "这个交通信号灯数据集由3个类别1484个彩色图像组成，即红灯、黄灯和绿灯。与大多数人工获取的数据一样，该数据在这些类型之间的分布并不均匀，具体为：\n",
    "* 904个红色交通灯图像\n",
    "* 536个绿色交通灯图像\n",
    "* 44个黄色交通灯图像\n",
    "\n",
    "*注：所有图像都来自[麻省理工学院的无人驾驶课程](https://selfdrivingcars.mit.edu/)，并符合 [知识共享署名许可协议-相同方式共享 4.0 国际许可协议](https://creativecommons.org/licenses/by-sa/4.0/) 。*\n",
    "\n",
    "### 导入资源\n",
    "\n",
    "在开始编写项目代码之前，请导入你需要的库和资源。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 # computer vision library\n",
    "import helpers # helper functions\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg # for loading in images\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练并测试数据\n",
    "\n",
    "所有1484个交通信号灯图像被将分成训练数据集和测试数据集。\n",
    "\n",
    "* 这些图像中的80％是训练图像，供你在创建分类器时使用。\n",
    "* 其余20％是测试图像，用于测试分类器的准确度。\n",
    "* 所有图像都是含有3种信号灯的交通灯图像，其中有一盏灯是亮起的。\n",
    "\n",
    "## 定义图像目录\n",
    "\n",
    "首先，我们设置一些变量来跟踪这些图像的存储位置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMAGE_DIR_TRAINING: the directory where our training image data is stored\n",
    "# IMAGE_DIR_TEST: the directory where our test image data is stored\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Image data directories\n",
    "IMAGE_DIR_TRAINING = \"traffic_light_images/training/\"\n",
    "IMAGE_DIR_TEST = \"traffic_light_images/test/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据集\n",
    "\n",
    "这些前几行代码将对训练交通信号灯图像进行加载，并将其全部存储在变量`IMAGE_LIST`中。该列表包含图像及其相关标签（“红灯”，“黄灯”，“绿灯”）。\n",
    "\n",
    "我们建议你查看helpers.py文件中的`load_dataset`函数。这个函数可以为你提供一个很好的思路，即如何使用[glob 库](https://pymotw.com/2/glob/)从一个目录中读取大量图像文件。 `load_dataset`函数可以输入图像目录的名称，然后返回图像及其相关标签的列表。\n",
    "\n",
    "例如，`IMAGE_LIST`中的第一个图像标签对可以通过索引访问："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "attributes": {
     "classes": [
      "IMAGE_LIST[0][:]```"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "# ```python\n",
    "# Using the load_dataset function in helpers.py\n",
    "# Load training data\n",
    "IMAGE_LIST = helpers.load_dataset(IMAGE_DIR_TRAINING)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可视化数据\n",
    "\n",
    "分析任何一个数据集的前两个步骤都是：1.加载数据；2.查看数据。看一看这些数据，你就会知道要在图像中寻找什么，需要处理什么样的噪音或不一致性等。这可以帮助你了解图像数据集，并且明白**了解数据集是对数据进行预测的一部分**。\n",
    "\n",
    "---\n",
    "### 将输入图像可视化\n",
    "\n",
    "将这些图像可视化，并对这些图像数据进行探究！编写代码，使其可以在`IMAGE_LIST`中显示图像：\n",
    "* 显示图像\n",
    "* 输出图像的形状\n",
    "* 输出相应的标签\n",
    "\n",
    "看一看是否可以显示出每种交通信号灯图像中的至少一种，即红灯，绿灯或黄灯，并查看它们的相似之处与差异之处。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of image of yellow traffic light is: (75, 32, 3)\n",
      "The label of selected image is: yellow\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f6bc302f240>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## TODO: Write code to display an image in IMAGE_LIST (try finding a yellow traffic light!)\n",
    "## TODO: Print out 1. The shape of the image and 2. The image's label\n",
    "\n",
    "# The first image in IMAGE_LIST is displayed below (without information about shape or label)\n",
    "selected_image = IMAGE_LIST[0][0]\n",
    "plt.imshow(selected_image)\n",
    "\n",
    "red_image = []\n",
    "yellow_image = []\n",
    "green_image = []\n",
    "\n",
    "for i in range(len(IMAGE_LIST)):\n",
    "    if (IMAGE_LIST[i][1] == \"red\"):\n",
    "        red_image.append(i)\n",
    "    elif (IMAGE_LIST[i][1] == \"yellow\"):\n",
    "        yellow_image.append(i)\n",
    "    else:\n",
    "        green_image.append(i)\n",
    "selected_yellow_image = IMAGE_LIST[725][0]\n",
    "selected_yellow_label = IMAGE_LIST[725][1]\n",
    "\n",
    "print(\"The shape of image of yellow traffic light is:\", selected_yellow_image.shape)\n",
    "print(\"The label of selected image is:\", selected_yellow_label)\n",
    "plt.imshow(selected_yellow_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 预处理数据\n",
    "\n",
    "每个图像中加载完成后，你必须使输入和输出标准化！\n",
    "\n",
    "### 输入\n",
    "\n",
    "这意味着每个输入图像都应采用相同的格式，大小相同等。我们将通过对每个图像执行相同的分析来创建特征，对于这样的分类任务，重要的是**类似的图像创建类似的特征**！\n",
    "\n",
    "### 输出\n",
    "\n",
    "我们还需要将输出结果作为易于阅读且易于与其他标签进行比较的标签。将“红灯”和“绿灯”等分类数据转换为数字数据，这是一种不错的做法。\n",
    "\n",
    "一个非常常见的分类输出是一维列表，它是指分类数的长度：在红灯、黄灯和绿灯的情况下为3； 值为0或1表示某个图像是某一类。例如，由于我们有三个类（红灯、黄灯和绿灯），则可以按顺序列出一个列表：[红灯值，黄灯值，绿灯值]。一般来说，顺序无关紧要，在这种情况下，我们选择的顺序是[红灯值，黄灯值，绿灯值]，便于反映垂直顺序中每个灯的位置。\n",
    "\n",
    "红灯的标签应该是：[1,0,0]，黄灯应该是：[0，1，0]，绿灯应该是：[0，0，1]。这些标签被称为**独热编码标签**。\n",
    "\n",
    "*（注：使用 [机器学习算法 ](https://machinelearningmastery.com/how-to-one-hot-encode-sequence-data-in-python/)时，独热编码将尤为重要）。*\n",
    "\n",
    "<img src=\"images/processing_steps.png\" width=\"80%\" height=\"80%\">\n",
    "\n",
    "---\n",
    "<a id='task2'></a>\n",
    "### （实现）：使输入图像标准化\n",
    "\n",
    "* 将每个图像调整为所需的输入尺寸：32x32px。\n",
    "* （可选）你也可以选择在此步骤中对图像进行裁剪、移动或旋转。\n",
    "\n",
    "一种很常见的尺寸是可旋转的方形输入尺寸（且保持相同尺寸），并且以较小的方块进行分析。将所有图像制作成相同的尺寸，便于它们可以通过相同的分类器步骤进行发送，这一点也很重要！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function should take in an RGB image and return a new, standardized version\n",
    "def standardize_input(image):\n",
    "    \n",
    "    ## TODO: Resize image and pre-process so that all \"standard\" images are the same size  \n",
    "    standard_im = np.copy(image)\n",
    "    standard_im = cv2.resize(standard_im, (32,32))    \n",
    "    return standard_im\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 标准化输出\n",
    "\n",
    "对于每个加载的图像，我们还指定了预期的输出。为此，我们使用**独热编码**。\n",
    "\n",
    "* 对标签进行独热编码。为此，请创建一个代表每类交通信号灯（红灯、黄灯、绿灯）的零数组，并将预期类别号的索引设置为1。\n",
    "\n",
    "由于我们有三类（红灯、黄灯和绿灯）交通信号灯图像，我们已经强制使用了一个顺序：[红灯值，黄灯值，绿灯值]。对于独热编码，例如黄灯，我们首先将数组初始化为[0,0,0]，然后将中间值（黄灯值）更改为1：[0,1,0]。\n",
    "\n",
    "---\n",
    "<a id='task3'></a>\n",
    "### （实现）：实现独热编码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: One hot encode an image label\n",
    "## Given a label - \"red\", \"green\", or \"yellow\" - return a one-hot encoded label\n",
    "\n",
    "# Examples: \n",
    "# one_hot_encode(\"red\") should return: [1, 0, 0]\n",
    "# one_hot_encode(\"yellow\") should return: [0, 1, 0]\n",
    "# one_hot_encode(\"green\") should return: [0, 0, 1]\n",
    "\n",
    "def one_hot_encode(label):\n",
    "    \n",
    "    ## TODO: Create a one-hot encoded label that works for all classes of traffic lights\n",
    "    one_hot_encoded = [] \n",
    "    if label == \"red\":\n",
    "        one_hot_encoded = [1,0,0]\n",
    "    elif label == \"yellow\":\n",
    "        one_hot_encoded = [0,1,0]\n",
    "    else:\n",
    "        one_hot_encoded = [0,0,1]\n",
    "    \n",
    "    \n",
    "    return one_hot_encoded\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试你的代码\n",
    "\n",
    "在对这样的函数完成编程之后，对它进行测试并查看它是否能够产生预期的输出。**一般来说，编写代码之后，最好在小的功能块中测试这些代码**。这样，不仅可以确保你的代码在继续构建分类器时是正确的，而且你也可以尽早地发现错误，以免它们混合。\n",
    "\n",
    "所有的测试代码都可以在文件`test_functions.py`中找到。如果你觉得有用的话，我们建议你查看该代码并添加自己的测试代码！\n",
    "\n",
    "你会在上述文件夹中看到一个测试函数：`test_one_hot(self, one_hot_function)`，它会输入一个参数，一个one_hot_encode函数，并测试该函数的函数性。如果你的one_hot_label代码无法按预期工作，则此测试将输出一条错误消息，告诉你一些关于代码失败的原因。你的代码开始运行后，应该输出TEST PASSED。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "**<span style=\"color: green;\">TEST PASSED</span>**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing the tests\n",
    "import test_functions\n",
    "tests = test_functions.Tests()\n",
    "\n",
    "# Test for one_hot_encode function\n",
    "tests.test_one_hot(one_hot_encode)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建一个输入图像并输出标签的`STANDARDIZED_LIST` 函数。\n",
    "\n",
    "该函数会输入一个图像标签对列表，并输出一个已调整过大小的图像和独热编码标签的**标准化**列表。\n",
    "\n",
    "这需要使用你在上面定义的那个函数来使输入和输出标准化，所以这些函数必须完整才能使完成这次标准化工作！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standardize(image_list):\n",
    "    \n",
    "    # Empty image data array\n",
    "    standard_list = []\n",
    "\n",
    "    # Iterate through all the image-label pairs\n",
    "    for item in image_list:\n",
    "        image = item[0]\n",
    "        label = item[1]\n",
    "\n",
    "        # Standardize the image\n",
    "        standardized_im = standardize_input(image)\n",
    "\n",
    "        # One-hot encode the label\n",
    "        one_hot_label = one_hot_encode(label)    \n",
    "\n",
    "        # Append the image, and it's one hot encoded label to the full, processed list of image data \n",
    "        standard_list.append((standardized_im, one_hot_label))\n",
    "        \n",
    "    return standard_list\n",
    "\n",
    "# Standardize all training images\n",
    "STANDARDIZED_LIST = standardize(IMAGE_LIST)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将标准化数据可视化\n",
    "\n",
    "显示来自STANDARDIZED_LIST的标准化图像，并将其与来自IMAGE_LIST的非标准化图像进行比较。请注意，它们的尺寸和外观是不同的！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f6bc2f3d0f0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## TODO: Display a standardized image and its label\n",
    "image_index = 7\n",
    "selected_std_image = STANDARDIZED_LIST[image_index][0]\n",
    "selected_std_label = STANDARDIZED_LIST[image_index][1]\n",
    "selected_nstd_image = IMAGE_LIST[image_index][0]\n",
    "selected_nstd_label = IMAGE_LIST[image_index][1]\n",
    "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15,10))\n",
    "ax1.set_title('Standardized image shape' + str(selected_std_image.shape) + 'and label ' + str(selected_std_label))\n",
    "ax1.imshow(selected_std_image)\n",
    "ax2.set_title('Non-Standardized image shape' + str(selected_nstd_image.shape) + 'and label ' + str(selected_nstd_label))\n",
    "ax2.imshow(selected_nstd_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 特征提取\n",
    "\n",
    "现在，你需要根据颜色空间、形状分析和特征构建方面的现有知识来创建特征，帮助区分和分类三种类型的交通信号灯图像。\n",
    "\n",
    "你需要创建至少**一项特征**（可选择创建更多特征）。必需的特征是**使用HSV颜色空间创建的亮度特征**：\n",
    "\n",
    "1. 亮度特征。\n",
    "    - 使用HSV颜色空间，创建一个特征，可用于帮你识别3种不同类别的交通信号灯。\n",
    "    - 稍后，你需要回答一个问题，即你刚刚试图用哪些方法来识别交通信号灯。所以，当你浏览这个notebook 时，需要一直思考你要使用的方法：什么方法有效，什么方法不可行？\n",
    "\n",
    "2. （可选）：创建更多特征！\n",
    "\n",
    "是否要创建更多特征，这取决于你，但是你创建的特征应该能提高交通信号灯分类算法的准确度！有一点需要注意的是，要通过这个项目，**绝不能将任何一个红灯归类为绿灯**，因为这会对无人驾驶汽车造成严重的安全风险。为了避免这种错误分类，你可以考虑添加另一个特别区分红灯和绿灯的特征。\n",
    "\n",
    "这些特征将会被合并在这个 notebook 的末尾处，从而形成一个完整的分类算法。\n",
    "\n",
    "## 创建亮度特征 \n",
    "\n",
    "创建亮度特征的方法有很多。亮度特征可以帮助你表示交通信号灯的图像特征。决定完成亮度特征创建的最佳步骤将由你来定。你应该随时查看并测试你的代码。\n",
    "\n",
    "下图是一个用于创建亮度特征（从左到右：标准化图像、HSV彩色图像、裁剪图像、亮度特征）的示例步骤：\n",
    "\n",
    "<img src=\"images/feature_ext_steps.png\" width=\"70%\" height=\"70%\">\n",
    "\n",
    "\n",
    "## RGB到HSV的转换\n",
    "\n",
    "下面，将测试图像从RGB转换为HSV颜色空间，并将每个组件显示在图像中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label [red, yellow, green]: [1, 0, 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f6bc2e1b4a8>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Convert and image to HSV colorspace\n",
    "# Visualize the individual color channels\n",
    "\n",
    "image_num = 0\n",
    "test_im = STANDARDIZED_LIST[image_num][0]\n",
    "test_label = STANDARDIZED_LIST[image_num][1]\n",
    "\n",
    "# Convert to HSV\n",
    "hsv = cv2.cvtColor(test_im, cv2.COLOR_RGB2HSV)\n",
    "\n",
    "# Print image label\n",
    "print('Label [red, yellow, green]: ' + str(test_label))\n",
    "\n",
    "# HSV channels\n",
    "h = hsv[:,:,0]\n",
    "s = hsv[:,:,1]\n",
    "v = hsv[:,:,2]\n",
    "\n",
    "# Plot the original image and the three channels\n",
    "f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(20,10))\n",
    "ax1.set_title('Standardized image')\n",
    "ax1.imshow(test_im)\n",
    "ax2.set_title('H channel')\n",
    "ax2.imshow(h, cmap='gray')\n",
    "ax3.set_title('S channel')\n",
    "ax3.imshow(s, cmap='gray')\n",
    "ax4.set_title('V channel')\n",
    "ax4.imshow(v, cmap='gray')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task7'></a>\n",
    "### （实现）：创建一个使用HSV颜色空间的亮度特征\n",
    "\n",
    "编写一个函数，它会输入一张RGB图像并返回一个一维特征矢量和/或单值，这有助于对交通信号灯图像进行分类。唯一的要求是该函数应该应用HSV颜色空间转换，其余的由你来决定。\n",
    "\n",
    "通过此函数，你应该能够判断一张图像的标签，并将其分类为红灯、绿灯或黄灯。如果辅助函数能够简化你的代码，你也可以定义几个辅助函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: Create a brightness feature that takes in an RGB image and outputs a feature vector and/or value\n",
    "## This feature should use HSV colorspace values\n",
    "def create_feature(rgb_image):\n",
    "    \n",
    "    ## TODO: Convert image to HSV color space\n",
    "    hsv = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2HSV)\n",
    "    \n",
    "    \n",
    "    # 定义颜色空间的特征\n",
    "    r_lower_hsv = np.array([125, 35, 105])\n",
    "    r_upper_hsv = np.array([190, 255, 255])\n",
    "    y_lower_hsv = np.array([15, 35, 115])\n",
    "    y_upper_hsv = np.array([70, 255, 255])\n",
    "    g_lower_hsv = np.array([70, 50, 110])\n",
    "    g_upper_hsv = np.array([100, 255, 255])\n",
    "    \n",
    "    # define the masked area\n",
    "    r_mask = cv2.inRange(hsv, r_lower_hsv, r_upper_hsv)\n",
    "    y_mask = cv2.inRange(hsv, y_lower_hsv, y_upper_hsv)\n",
    "    g_mask = cv2.inRange(hsv, g_lower_hsv, g_upper_hsv)\n",
    "    \n",
    "    r_masked_image = np.copy(rgb_image)\n",
    "    y_masked_image = np.copy(rgb_image)\n",
    "    g_masked_image = np.copy(rgb_image)\n",
    "    \n",
    "    r_masked_image[r_mask == 0] = [0, 0, 0]\n",
    "    y_masked_image[y_mask == 0] = [0, 0, 0]\n",
    "    g_masked_image[g_mask == 0] = [0, 0, 0]\n",
    "\n",
    "    r_feature = np.sum(r_masked_image[:,:,:])\n",
    "    y_feature = np.sum(y_masked_image[:,:,:])\n",
    "    g_feature = np.sum(g_masked_image[:,:,:])\n",
    "    \n",
    "    ## TODO: Create and return a feature value and/or vector\n",
    "    feature = []\n",
    "    if (r_feature > y_feature and r_feature > g_feature):\n",
    "        feature = [1, 0, 0]\n",
    "    elif (y_feature > r_feature and y_feature > g_feature):\n",
    "        feature = [0, 1, 0]\n",
    "    else:\n",
    "        feature = [0, 0, 1]\n",
    "    \n",
    "    return feature\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （可选）创建更多特征，用于帮助准确标记交通信号灯图像"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (Optional) Add more image analysis and create more features\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## （问题1）：你创建的特征如何帮你区分这3类交通信号灯图像？\n",
    "\n",
    "**答案：**\n",
    "在这个单元格中写下你的答案。\n",
    "\n",
    "`我发现一些红色的交通灯看起来像有很多黄色在红色的中间，因为亮度高，所以我定义了不同HSV颜色空间的红、黄、绿交通灯图像。该特征函数计算了色相、饱和度和亮度的总特征。`\n",
    "\n",
    "# 4. 进行分类，并将错误可视化\n",
    "\n",
    "使用你创建的所有特征，编写一个可以输入一张RGB图像的函数，并使用提取的特征，输出一个灯光是红色、绿色或者黄色，并将该结果作为独热编码标签。这种分类函数应该能够对任何一张交通信灯图像进行分类！\n",
    "\n",
    "我们建议你编写可能会用到的任何一种辅助函数或可视化代码，但为了测试准确度，请确保此`estimate_label`函数返回一个独热编码标签。\n",
    "\n",
    "---\n",
    "<a id='task8'></a>\n",
    "### （实现）：构建一个完整的分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function should take in RGB image input\n",
    "# Analyze that image using your feature creation code and output a one-hot encoded label\n",
    "def estimate_label(rgb_image):\n",
    "    \n",
    "    ## TODO: Extract feature(s) from the RGB image and use those features to\n",
    "    ## classify the image and output a one-hot encoded label\n",
    "    predicted_label = create_feature(rgb_image)\n",
    "    \n",
    "    return predicted_label   \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试分类器\n",
    "\n",
    "这里，我们使用这个 notebook 开始部分的测试数据集，对你的分类算法进行测试！编写完了一个“好”的分类器后，这个项目就算是完整的。\n",
    "\n",
    "在这种案例中，一个“好”的分类器应符合以下标准（只要符合，就可以随时提交你的项目）：\n",
    "1. 分类准确度达到90％以上。\n",
    "2. 切勿将任何一个红灯归类为绿灯。\n",
    "\n",
    "### 测试数据集\n",
    "\n",
    "在下面，我们首先加载测试数据集，然后使用上面定义的`standardize`函数对其进行标准化，然后对其进行**混洗**；这样可以确保顺序不会对准确度测试造成影响。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the load_dataset function in helpers.py\n",
    "# Load test data\n",
    "TEST_IMAGE_LIST = helpers.load_dataset(IMAGE_DIR_TEST)\n",
    "\n",
    "# Standardize the test data\n",
    "STANDARDIZED_TEST_LIST = standardize(TEST_IMAGE_LIST)\n",
    "\n",
    "# Shuffle the standardized test data\n",
    "random.shuffle(STANDARDIZED_TEST_LIST)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 确定准确度\n",
    "\n",
    "将你的分类算法（也称为“模型”）的输出与真实标签进行比较并确定准确度。\n",
    "\n",
    "此代码将所有错误分类的图像、其预测标签以及它们的真实标签存储在名为`MISCLASSIFIED`的列表中。此代码用于测试，*不应更改*。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9865319865319865\n",
      "Number of misclassified images = 4 out of 297\n"
     ]
    }
   ],
   "source": [
    "# Constructs a list of misclassified images given a list of test images and their labels\n",
    "# This will throw an AssertionError if labels are not standardized (one-hot encoded)\n",
    "\n",
    "def get_misclassified_images(test_images):\n",
    "    # Track misclassified images by placing them into a list\n",
    "    misclassified_images_labels = []\n",
    "\n",
    "    # Iterate through all the test images\n",
    "    # Classify each image and compare to the true label\n",
    "    for image in test_images:\n",
    "\n",
    "        # Get true data\n",
    "        im = image[0]\n",
    "        true_label = image[1]\n",
    "        assert(len(true_label) == 3), \"The true_label is not the expected length (3).\"\n",
    "\n",
    "        # Get predicted label from your classifier\n",
    "        predicted_label = estimate_label(im)\n",
    "        assert(len(predicted_label) == 3), \"The predicted_label is not the expected length (3).\"\n",
    "\n",
    "        # Compare true and predicted labels \n",
    "        if(predicted_label != true_label):\n",
    "            # If these labels are not equal, the image has been misclassified\n",
    "            misclassified_images_labels.append((im, predicted_label, true_label))\n",
    "            \n",
    "    # Return the list of misclassified [image, predicted_label, true_label] values\n",
    "    return misclassified_images_labels\n",
    "\n",
    "\n",
    "# Find all misclassified images in a given test set\n",
    "MISCLASSIFIED = get_misclassified_images(STANDARDIZED_TEST_LIST)\n",
    "\n",
    "# Accuracy calculations\n",
    "total = len(STANDARDIZED_TEST_LIST)\n",
    "num_correct = total - len(MISCLASSIFIED)\n",
    "accuracy = num_correct/total\n",
    "\n",
    "print('Accuracy: ' + str(accuracy))\n",
    "print(\"Number of misclassified images = \" + str(len(MISCLASSIFIED)) +' out of '+ str(total))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task9'></a>\n",
    "### 将错误分类的图像可视化\n",
    "\n",
    "将分类错误的一些图像（在`MISCLASSIFIED`列表中）可视化，并注意那些难以使它们归类的任何一个特征。这样做可以帮助你识别分类算法中的缺陷。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2880x1440 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize misclassified example(s)\n",
    "## TODO: Display an image in the `MISCLASSIFIED` list \n",
    "## TODO: Print out its predicted label - to see what the image *was* incorrectly classified as\n",
    "plt.figure(figsize=(40,20))\n",
    "for i in range(len(MISCLASSIFIED)):\n",
    "    plt.subplot(10,1,i+1)\n",
    "    mis_image = MISCLASSIFIED[i][0]\n",
    "    predicted_label = MISCLASSIFIED[i][1]\n",
    "    plt.title('predicted_result is: ' + str(predicted_label))\n",
    "    plt.imshow(mis_image)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='question2'></a>\n",
    "## （问题2）：在将这些误分类可视化之后，你认为你的分类算法存在哪些缺陷？请至少发现两个缺陷。\n",
    "\n",
    "**答案：** 在这个单元格中写下你的答案。\n",
    "\n",
    "`3/4的错误分类是黄色和红色的混合。必须添加其他特征，如位置。我的分类对于参数的调整是不灵活，更多的是用直觉和运气来进行调整`\n",
    "\n",
    "## 测试你是否将某一个红灯归类为绿灯\n",
    "\n",
    "**要通过这个项目，你不能将任何一个红灯归类为绿灯！**将红灯分类为绿灯会将导致汽车出现闯红灯行驶的情况，因此这种“把红灯误看做是绿灯”的错误在现实世界中非常危险。\n",
    "\n",
    "下面的代码可以让你测试是否将测试集中的任何一个红灯错误归类为绿灯。**这个测试假定 `MISCLASSIFIED` 是一个元组列表，其顺序是： [misclassified_image, predicted_label, true_label]** 。\n",
    "\n",
    "注：这不是一个全面的测试，但它是一个很好的指标。如果你通过了这个测试，说明你已经掌握了这部分知识！这个测试会遍历错误分类的例子列表，并检查是否存在任何一个红灯被错误标记为[0,1,0]（绿灯）的情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "**<span style=\"color: green;\">TEST PASSED</span>**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing the tests\n",
    "import test_functions\n",
    "tests = test_functions.Tests()\n",
    "\n",
    "if(len(MISCLASSIFIED) > 0):\n",
    "    # Test code for one_hot_encode function\n",
    "    tests.test_red_as_green(MISCLASSIFIED)\n",
    "else:\n",
    "    print(\"MISCLASSIFIED may not have been populated with images.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 改进你的算法！\n",
    "\n",
    "**完成所有任务并且符合以下两个标准，并回答完所有问题后，请提交你的项目：**\n",
    "1. 分类准确度超过90％；\n",
    "2. 没有将任何一个红灯归类为绿灯。\n",
    "\n",
    "如果不符合这两个要求（这在第一次尝试中很常见！），请重新查看你的算法并对其进行改进，改善光线识别 - 这可能意味着更改亮度特征，执行一些背景减除或添加其他特征！\n",
    "\n",
    "---\n",
    "\n",
    "### 接受进一步挑战（可选性挑战项目）\n",
    "\n",
    "如果你发现这个挑战项目太过容易，我建议你去挑战一些更有难度的项目！ 这里有几个**可选** 项目（意思是说，执行下面这些项目后，你不需要进行提交，也不需要必须通过这些项目）：\n",
    "* （可选）尽可能使分类准确度> 95％。\n",
    "* （可选）一些灯呈箭头形状；进一步将灯光分类为圆形或箭头形。\n",
    "* （可选）添加另一个特征，尽可能使准确度接近100％！"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
